home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / wb / czesc_4 / startwindow / source / startwindow.c < prev    next >
C/C++ Source or Header  |  1994-11-02  |  17KB  |  602 lines
  1. /*
  2.  *  Source machine generated by GadToolsBox V2.0b
  3.  *  which is (c) Copyright 1991-1993 Jaba Development
  4.  *
  5.  *  GUI Designed by : -- Heinz Reinert --
  6.  */
  7. #include <exec/types.h>
  8. #include <string.h>
  9. #include <intuition/intuition.h>
  10. #include <intuition/classes.h>
  11. #include <intuition/classusr.h>
  12. #include <intuition/imageclass.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <libraries/gadtools.h>
  15. #include <graphics/displayinfo.h>
  16. #include <graphics/GfxBase.h>
  17. #include <clib/exec_protos.h>
  18. #include <clib/intuition_protos.h>
  19. #include <clib/gadtools_protos.h>
  20. #include <clib/graphics_protos.h>
  21. #include <clib/utility_protos.h>
  22. #include <proto/intuition.h>
  23. #include <proto/graphics.h>
  24. #include <proto/exec.h>
  25. #include <proto/dos.h>
  26. #include <proto/gadtools.h>
  27. #include <exec/memory.h>
  28.  
  29.  
  30. /***************************************/
  31. #define GetString( g )      ((( struct StringInfo * )g->SpecialInfo )->Buffer  )
  32. #define GetNumber( g )      ((( struct StringInfo * )g->SpecialInfo )->LongInt )
  33.  
  34. #define GD_list                                0
  35. #define GD_gadtxt                              1
  36. #define GD_command                             2
  37. #define GD_command2                            3
  38. #define GD_new                                 4
  39. #define GD_del                                 5
  40. #define GD_start                               6
  41. #define GD_save                                7
  42. #define GD_req                                 8
  43.  
  44. #define GDX_list                               0
  45. #define GDX_gadtxt                             1
  46. #define GDX_command                            2
  47. #define GDX_command2                           3
  48. #define GDX_new                                4
  49. #define GDX_del                                5
  50. #define GDX_start                              6
  51. #define GDX_save                               7
  52. #define GDX_req                                8
  53.  
  54. #define Project0_CNT 9
  55. UBYTE *vers = "\0$VER: StartWindow 2";
  56.  
  57. extern struct IntuitionBase *IntuitionBase;
  58. extern struct Library       *GadToolsBase;
  59.  
  60. extern struct Screen        *Scr;
  61. extern UBYTE                 *PubScreenName;
  62. extern APTR                  VisualInfo;
  63. extern struct Window        *Project0Wnd;
  64. extern struct Gadget        *Project0GList;
  65. extern struct Gadget        *Project0Gadgets[9];
  66. extern UWORD                 Project0Left;
  67. extern UWORD                 Project0Top;
  68. extern UWORD                 Project0Width;
  69. extern UWORD                 Project0Height;
  70. extern UBYTE                *Project0Wdt;
  71. extern struct TextAttr       topaz8;
  72. extern UWORD                 Project0GTypes[];
  73. extern struct NewGadget      Project0NGad[];
  74. extern ULONG                 Project0GTags[];
  75.  
  76.  
  77. extern int SetupScreen( void );
  78. extern void CloseDownScreen( void );
  79. extern int OpenProject0Window( void );
  80. extern void CloseProject0Window( void );
  81.  
  82. /***************************************/
  83.  
  84. struct Screen         *Scr = NULL;
  85. UBYTE                 *PubScreenName = NULL;
  86. APTR                   VisualInfo = NULL;
  87. struct Window         *Project0Wnd = NULL;
  88. struct Gadget         *Project0GList = NULL;
  89. struct Gadget         *Project0Gadgets[9];
  90. UWORD                  Project0Left = 440;
  91. UWORD                  Project0Top = 10;
  92. UWORD                  Project0Width = 190;
  93. UWORD                  Project0Height = 0;
  94. UBYTE                 *Project0Wdt = (UBYTE *)"StartWindow2";
  95.  
  96. struct TextAttr topaz8 = {
  97.         ( STRPTR )"topaz.font", 8, 0x00, 0x01 };
  98.  
  99. UWORD Project0GTypes[] = {
  100.         LISTVIEW_KIND,
  101.         STRING_KIND,
  102.         STRING_KIND,
  103.         STRING_KIND,
  104.         BUTTON_KIND,
  105.         BUTTON_KIND,
  106.         BUTTON_KIND,
  107.         BUTTON_KIND,
  108.         BUTTON_KIND
  109. };
  110.  
  111. struct NewGadget Project0NGad[] = {
  112.         4, 2, 161, 88, NULL, NULL, GD_list, 0, NULL, NULL,
  113.         4, 86, 138, 12, NULL, NULL, GD_gadtxt, 0, NULL, NULL,
  114.         4, 98, 161, 12, NULL, NULL, GD_command, 0, NULL, NULL,
  115.         4, 110, 161, 12, NULL, NULL, GD_command2, 0, NULL, NULL,
  116.         4, 122, 54, 11, (UBYTE *)"NEW", NULL, GD_new, PLACETEXT_IN, NULL, NULL,
  117.         114, 122, 51, 11, (UBYTE *)"DEL", NULL, GD_del, PLACETEXT_IN, NULL, NULL,
  118.         4, 133, 161, 13, (UBYTE *)"RUN", NULL, GD_start, PLACETEXT_IN, NULL, NULL,
  119.         59, 122, 54, 11, (UBYTE *)"SAVE", NULL, GD_save, PLACETEXT_IN, NULL, NULL,
  120.         142, 86, 23, 12, (UBYTE *)"R", NULL, GD_req, PLACETEXT_IN, NULL, NULL
  121. };
  122.  
  123. ULONG Project0GTags[] = {
  124.         (TAG_DONE),
  125.         (GTST_MaxChars), 256, (TAG_DONE),
  126.         (GTST_MaxChars), 256, (TAG_DONE),
  127.         (GTST_MaxChars), 256, (TAG_DONE),
  128.         (TAG_DONE),
  129.         (TAG_DONE),
  130.         (TAG_DONE),
  131.         (TAG_DONE),
  132.         (TAG_DONE)
  133. };
  134.  
  135. int SetupScreen( void )
  136. {
  137.         if ( ! ( Scr = LockPubScreen( PubScreenName )))
  138.                 return( 1L );
  139.  
  140.         if ( ! ( VisualInfo = GetVisualInfo( Scr, TAG_DONE )))
  141.                 return( 2L );
  142.  
  143.         return( 0L );
  144. }
  145.  
  146. void CloseDownScreen( void )
  147. {
  148.         if ( VisualInfo ) {
  149.                 FreeVisualInfo( VisualInfo );
  150.                 VisualInfo = NULL;
  151.         }
  152.  
  153.         if ( Scr        ) {
  154.                 UnlockPubScreen( NULL, Scr );
  155.                 Scr = NULL;
  156.         }
  157. }
  158.  
  159. int OpenProject0Window( void )
  160. {
  161.         struct NewGadget        ng;
  162.         struct Gadget   *g;
  163.         UWORD           lc, tc;
  164.         UWORD           offx = Scr->WBorLeft, offy = Scr->WBorTop + Scr->RastPort.TxHeight + 1;
  165.  
  166.         if ( ! ( g = CreateContext( &Project0GList )))
  167.                 return( 1L );
  168.  
  169.         for( lc = 0, tc = 0; lc < Project0_CNT; lc++ ) {
  170.  
  171.                 CopyMem((char * )&Project0NGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
  172.  
  173.                 ng.ng_VisualInfo = VisualInfo;
  174.                 ng.ng_TextAttr   = &topaz8;
  175.                 ng.ng_LeftEdge  += offx;
  176.                 ng.ng_TopEdge   += offy;
  177.  
  178.                 Project0Gadgets[ lc ] = g = CreateGadgetA((ULONG)Project0GTypes[ lc ], g, &ng, ( struct TagItem * )&Project0GTags[ tc ] );
  179.  
  180.                 while( Project0GTags[ tc ] ) tc += 2;
  181.                 tc++;
  182.  
  183.                 if ( NOT g )
  184.                         return( 2L );
  185.         }
  186.  
  187.         if ( ! ( Project0Wnd = OpenWindowTags( NULL,
  188.                                 WA_Left,        Project0Left,
  189.                                 WA_Top,         Project0Top,
  190.                                 WA_Width,       Project0Width,
  191.                                 WA_Height,      Project0Height + offy,
  192.                                 WA_IDCMP,       LISTVIEWIDCMP|STRINGIDCMP|BUTTONIDCMP|IDCMP_CLOSEWINDOW|IDCMP_REFRESHWINDOW,
  193.                                 WA_Flags,       WFLG_SIZEGADGET|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH,
  194.                                 WA_Gadgets,     Project0GList,
  195.                                 WA_Title,       Project0Wdt,
  196.                                 WA_ScreenTitle, "StartWindow2 Heinz Reinert 1994",
  197.                                 WA_PubScreen,   Scr,
  198.                                 WA_MinWidth,    190,
  199.                                 WA_MinHeight,   160,
  200.                                 WA_MaxWidth,    190,
  201.                                 WA_MaxHeight,   160,
  202.                                 TAG_DONE )))
  203.         return( 4L );
  204.  
  205.         GT_RefreshWindow( Project0Wnd, NULL );
  206.  
  207.         return( 0L );
  208. }
  209.  
  210. void CloseProject0Window( void )
  211. {
  212.         if ( Project0Wnd        ) {
  213.                 CloseWindow( Project0Wnd );
  214.                 Project0Wnd = NULL;
  215.         }
  216.  
  217.         if ( Project0GList      ) {
  218.                 FreeGadgets( Project0GList );
  219.                 Project0GList = NULL;
  220.         }
  221. }
  222.  
  223. /*********************************************/
  224. /* Main Program Part */
  225.  
  226.  
  227. /* Structur for Data-Entries */
  228.  
  229. struct PRJ {
  230.  
  231.     char    Name[0];
  232.  
  233.     char    gadtxt[20];
  234.     char    command[75];
  235.     char    command2[75];
  236.     USHORT  new;
  237.     USHORT  del;
  238.     USHORT  save;
  239.     USHORT  req;
  240.     USHORT  start;
  241. };
  242.  
  243. struct PRJnode {
  244.         struct  Node n;
  245.         struct  PRJ d;
  246. };
  247.  
  248. /* PRJ-Nodes are in this List */
  249.  
  250. struct List prjlist;
  251.  
  252. /* The actual Entry */
  253.  
  254. struct PRJnode *currentprj;
  255.  
  256. /* String-Gadgets */
  257.  
  258. void gt_SetString( struct Gadget        *gad,
  259.                                    struct Window        *w,
  260.                                    char                         *string )
  261. {
  262.         GT_SetGadgetAttrs( gad, w, NULL, GTST_String, string, TAG_DONE );
  263. }
  264.  
  265. char * gt_GetString( struct Gadget      *gad )
  266. {
  267.         struct StringInfo *si = gad->SpecialInfo;
  268.  
  269.         if( si )
  270.                 return( ( char * ) si->Buffer );
  271.         else
  272.                 return( NULL );
  273. }
  274.  
  275. /* Manage Lists for Listview-Gadgets */
  276. /* Add List */
  277.  
  278. void gt_AttachList(     struct Gadget   *lv,
  279.                                         struct Window   *w,
  280.                                         struct List     *list )
  281. {
  282.         GT_SetGadgetAttrs( lv, w, NULL, GTLV_Labels, list, TAG_DONE );
  283. }
  284.  
  285. /* Put Actuel Entry */
  286.  
  287. void gt_SetLV( struct Gadget    *gad,
  288.                            struct Window        *w,
  289.                            ULONG                        value)
  290. {
  291.         GT_SetGadgetAttrs( gad, w, NULL, GTLV_Selected, value, TAG_DONE );
  292. }
  293.  
  294. /* get x-Entry from Exec-List */
  295.  
  296. struct Node * gt_GetListEntry( struct List *l,
  297.                                                            int num )
  298. {
  299.         int count = 0;
  300.         struct Node *n = l->lh_Head;
  301.  
  302.         while( n->ln_Succ )
  303.         {
  304.                 if( num==count ) return( n );
  305.                 n = n->ln_Succ;
  306.                 count++;
  307.         }
  308.         return( NULL );
  309. }
  310.  
  311. /* Number of a Node in List? */
  312.  
  313. int gt_GetListEntryNum( struct List *l,
  314.                                                 struct Node *n )
  315. {
  316.         int count = 0;
  317.         struct Node *r = l->lh_Head;
  318.  
  319.         while( r->ln_Succ )
  320.         {
  321.                 if( r==n ) return( count );
  322.                 r = r->ln_Succ;
  323.                 count++;
  324.         }
  325.         return( -1 );
  326. }
  327.  
  328. /* Count Entries of List */
  329.  
  330. int gt_GetListNumEntries( struct List *l )
  331. {
  332.         int count = 0;
  333.         struct Node *n = l->lh_Head;
  334.  
  335.         while( n->ln_Succ )
  336.         {
  337.                 n = n->ln_Succ;
  338.                 count++;
  339.         }
  340.  
  341.         return( count );
  342. }
  343.  
  344. /************************************************************************/
  345.  
  346. /* Load Command.DAT */
  347.  
  348. void loadprjlist( void )
  349. {
  350.         struct PRJ new;
  351.         struct PRJnode *n;
  352.         BPTR f;
  353.  
  354.         /* Init List */
  355.         NewList( &prjlist );
  356.         currentprj = NULL;
  357.  
  358.         /* Open Command.DAT */
  359.         f = Open( "S:Command.DAT", MODE_OLDFILE );
  360.         if( !f )
  361.                 return;
  362.  
  363.         /* Inputs read in */
  364.         while( Read( f, &new, sizeof( new ) ) == sizeof( new ) )
  365.         {
  366.                /* New Node */
  367.                 n = AllocVec( sizeof( *n ), 0 );
  368.                 if( !n )
  369.                         break;
  370.  
  371.         /* Copy Structur and add to List */
  372.                 n->d = new;
  373.                 n->n.ln_Name = n->d.Name;
  374.                 n->n.ln_Pri      = - n->d.Name[0];
  375.                 Enqueue( &prjlist, (struct Node *) n );
  376.         }
  377.  
  378.         Close( f );
  379. }
  380.  
  381. /* Saves List and Frees it */
  382. void save_and_freeprjlist( void )
  383. {
  384.         struct PRJnode *n;
  385.         BPTR f;
  386.  
  387.         f = Open( "S:Command.DAT", MODE_NEWFILE );
  388.  
  389.         while( ( n = (struct PRJnode * ) RemHead( &prjlist ) ) )
  390.         {
  391.             /* Save Node */
  392.                 if( f )
  393.                         Write( f, &n->d, sizeof( struct PRJ ) );
  394.             /* Free Node */
  395.                 FreeVec( n );
  396.         }
  397.  
  398.         if( f )
  399.                 Close( f );
  400. }
  401.  
  402.  
  403. /************************************************************************/
  404.  
  405. /* Puts actual Structur-Values to Gadgets */
  406.  
  407. void setgadvals( void )
  408. {
  409.  
  410.         if( !currentprj )
  411.             return;
  412.  
  413.         gt_SetString(   Project0Gadgets[ GD_gadtxt ], Project0Wnd,
  414.                                                        currentprj->d.Name );
  415.  
  416.         gt_SetString(   Project0Gadgets[ GD_command ], Project0Wnd,
  417.                                                     currentprj->d.command );
  418.  
  419.         gt_SetString(   Project0Gadgets[ GD_command2 ], Project0Wnd,
  420.                                                     currentprj->d.command2 );
  421.  
  422. }
  423.  
  424. /* Create a new Empty Input */
  425.  
  426. void newprj( void )
  427. {
  428.         struct PRJnode *new;
  429.  
  430.         new = AllocVec( sizeof( *new ), MEMF_CLEAR );
  431.  
  432.         if( !new )
  433.                 return;
  434.  
  435.         currentprj = new;
  436.  
  437.         new->n.ln_Name = new->d.Name;
  438.  
  439.         strcpy( new->d.Name, "new" );
  440.  
  441.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd,
  442.                                                       (struct List *) ~0 );
  443.  
  444.         new->n.ln_Pri    = - new->d.Name[0];
  445.         Enqueue( &prjlist, (struct Node *) new );
  446.  
  447.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, &prjlist );
  448.  
  449.         gt_SetLV( Project0Gadgets[GD_list], Project0Wnd,
  450.                                      gt_GetListEntryNum( &prjlist, new ) );
  451.         setgadvals();
  452. }
  453.  
  454. /* Work on Gadget-Event */
  455. void dogadup( struct IntuiMessage *im )
  456. {
  457.         struct Gadget *g = im->IAddress;
  458.  
  459.         switch( g->GadgetID )
  460.         {
  461.  
  462. /*** Enter List ***/
  463. case GD_list:
  464.         currentprj = (struct PRJnode *) gt_GetListEntry( &prjlist, im->Code );
  465.         setgadvals();
  466.         break;
  467.  
  468. /*** New ***/
  469. case GD_new:
  470.         newprj();
  471.         break;
  472.  
  473. /*** Delete ***/
  474. case GD_del:
  475.         if( currentprj )
  476.         {
  477.         gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd,
  478.                                                        (struct List *) ~0 );
  479.         Remove( currentprj );
  480.         FreeVec( currentprj );
  481.         currentprj = FALSE;
  482.         gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, &prjlist );
  483.         gt_SetLV( Project0Gadgets[ GD_list ], Project0Wnd, ~0 );
  484.         }
  485.         break;
  486. /*** Program Name ***/
  487. case GD_gadtxt:
  488.         if( currentprj )
  489.         {
  490.         gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd,
  491.                                                          (struct List *) ~0 );
  492.    strcpy( currentprj->d.Name, gt_GetString( Project0Gadgets[ GD_gadtxt ] ) );
  493.         gt_AttachList( Project0Gadgets[ GD_list ], Project0Wnd, &prjlist );
  494.         }
  495.         break;
  496.  
  497. /*** Command-string ***/
  498. case GD_command:
  499.         if( currentprj )
  500.         strcpy( currentprj->d.command,
  501.                              gt_GetString( Project0Gadgets[ GD_command ] ) );
  502.         break;
  503.  
  504. /*** Command-string ***/
  505. case GD_command2:
  506.         if( currentprj )
  507.         strcpy( currentprj->d.command2,
  508.                              gt_GetString( Project0Gadgets[ GD_command2 ] ) );
  509.         break;
  510.  
  511. /*** Start Program ***/
  512. case GD_start:
  513.         Execute(currentprj->d.command, NULL, Output());
  514.         Execute("WAIT 2 secs ", NULL, Output());
  515.         Execute(currentprj->d.command2, NULL, Output());
  516.         break;
  517.  
  518. /*** Save List ***/
  519. case GD_save:
  520.         {
  521.             save_and_freeprjlist();
  522.             loadprjlist();
  523.         }
  524.         break;
  525.  
  526. /*** Requester ***/
  527. case GD_req:
  528.            Execute("RUN >NIL: RequShell", NULL, Output());
  529.         break;
  530.         }
  531. }
  532.  
  533. /* Program start */
  534.  
  535. int main( void )
  536. {
  537.  
  538.         struct IntuiMessage     *im,imsg;
  539.         BOOL   Done = FALSE;
  540.  
  541.         /*** Open Screen and Window ***/
  542.         SetupScreen();
  543.         OpenProject0Window();
  544.  
  545.         /*** Load List ***/
  546.         loadprjlist();
  547.  
  548.         /*** Show List ***/
  549.         gt_AttachList( Project0Gadgets[GD_list], Project0Wnd, &prjlist );
  550.  
  551.         /*** Main Loop ***/
  552.         while( !Done )
  553.         {
  554.                 /*** Wait for IntuiMessage ***/
  555.  
  556.                 while( !( im=GT_GetIMsg( Project0Wnd->UserPort ) ) )
  557.                         WaitPort( Project0Wnd->UserPort );
  558.  
  559.                 /*** Copy ***/
  560.                 imsg = *im;
  561.                 GT_ReplyIMsg( im );
  562.  
  563.                 switch( imsg.Class )
  564.                 {
  565.             /*** CLOSEWINDOW: Close Window ***/
  566.                         case IDCMP_CLOSEWINDOW:
  567.                                 Done = TRUE;
  568.                                 break;
  569.  
  570.             /*** Gadgetup; Gadget selected ***/
  571.                         case GADGETUP:
  572.                                 dogadup( &imsg );
  573.                                 break;
  574.  
  575.             /*** REFRESH: Graphicobjects (Boxen) redraw ***/
  576.                         case IDCMP_REFRESHWINDOW:
  577.                                 GT_BeginRefresh( Project0Wnd );
  578.                                 GT_EndRefresh( Project0Wnd, TRUE );
  579.                                 break;
  580.  
  581.                 }
  582.  
  583.         }
  584.  
  585.         /*** Close Window and Screen ***/
  586.         CloseProject0Window();
  587.         CloseDownScreen();
  588.  
  589.         /*** Save List ***/
  590.         save_and_freeprjlist();
  591.  
  592.         return(0);
  593. }
  594.  
  595.  
  596.  
  597.  
  598.  
  599.  
  600.  
  601.  
  602.